{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * final curated dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/extended_22_run_13/1/AstroCNNModel_extended_20210123_230247',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/2/AstroCNNModel_extended_20210123_233704',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/3/AstroCNNModel_extended_20210124_001135',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/4/AstroCNNModel_extended_20210124_004519',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/5/AstroCNNModel_extended_20210124_011920',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/6/AstroCNNModel_extended_20210124_015336',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/7/AstroCNNModel_extended_20210124_022808',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/8/AstroCNNModel_extended_20210124_030218',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/9/AstroCNNModel_extended_20210124_033541',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/10/AstroCNNModel_extended_20210124_040845']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/extended_22_run_13'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-22-train/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v5-train.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "17872 records\n",
      "Running model 2\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "17872 records\n",
      "Running model 3\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "17872 records\n",
      "Running model 4\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "17872 records\n",
      "Running model 5\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "17872 records\n",
      "Running model 7\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "17872 records\n",
      "Running model 8\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "17872 records\n",
      "Running model 9\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "3292 records"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_E', 'disp_N', 'disp_J', 'disp_S', 'disp_B']\n",
    "\n",
    "col_e = labels.index('disp_E')\n",
    "thresh = config.hparams.prediction_threshold\n",
    "thresh = 0.95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_E')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9472851871375857\n",
      "Precision: 0.9692556634304207\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_E_p'] > 0)\n",
    "pos = (pl['disp_E'] > 0)\n",
    "\n",
    "pneg = (pl['disp_E_p'] == 0)\n",
    "neg = (pl['disp_E'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "379464439\n",
      "381366555\n",
      "383390727\n",
      "383390914\n",
      "383716793\n",
      "389013422\n",
      "389364577\n",
      "394232334\n",
      "404797784\n",
      "404853708\n",
      "405952536\n",
      "409651781\n",
      "409851100\n",
      "114053589\n",
      "118324224\n",
      "120397217\n",
      "129036837\n",
      "141029164\n",
      "169316288\n",
      "444043522\n",
      "310004006\n",
      "387829772\n",
      "288346083\n",
      "298734307\n",
      "298757219\n",
      "179308589\n",
      "182894670\n",
      "183073148\n",
      "200135791\n",
      "201635971\n",
      "238183537\n",
      "260472863\n",
      "261262721\n",
      "357046804\n",
      "266676103\n",
      "286330326\n",
      "286405674\n",
      "306059878\n",
      "409726763\n",
      "81749728\n",
      "87593814\n",
      "30639928\n",
      "306511505\n",
      "309434156\n",
      "31532677\n",
      "322284851\n",
      "325339373\n",
      "339600659\n",
      "425064757\n",
      "425561347\n",
      "446523110\n",
      "49137560\n",
      "56773241\n",
      "85765877\n",
      "268608949\n",
      "272178884\n",
      "272181655\n",
      "279021812\n",
      "428404278\n",
      "92328347\n",
      "115684219\n",
      "136971594\n",
      "289236608\n",
      "358715557\n",
      "293346794\n",
      "293664120\n",
      "294092966\n",
      "294871044\n",
      "300405121\n",
      "306103891\n",
      "343452418\n",
      "364112579\n",
      "364951842\n",
      "369860950\n",
      "373849740\n",
      "376936788\n",
      "198410480\n",
      "277015008\n",
      "277123828\n",
      "277316602\n",
      "279958090\n",
      "287156968\n",
      "321915222\n",
      "326974824\n",
      "202489696\n",
      "27491137\n",
      "305876160\n",
      "420115946\n",
      "176551075\n",
      "186400565\n",
      "26516151\n",
      "306263608\n",
      "57919833\n",
      "96785948\n",
      "138588540\n",
      "138618351\n",
      "142748406\n",
      "332146607\n",
      "356630364\n",
      "154068411\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "384077498\n",
      "389363745\n",
      "404768904\n",
      "404851226\n",
      "101654574\n",
      "119384992\n",
      "179308949\n",
      "180416902\n",
      "220375993\n",
      "25078924\n",
      "261136311\n",
      "377197068\n",
      "239814191\n",
      "267694283\n",
      "309682332\n",
      "414897731\n",
      "445706410\n",
      "31415158\n",
      "31634175\n",
      "424879951\n",
      "456588598\n",
      "464488581\n",
      "49449799\n",
      "50308490\n",
      "79655149\n",
      "88353444\n",
      "233896030\n",
      "329704753\n",
      "378275445\n",
      "43667308\n",
      "91001369\n",
      "40993256\n",
      "420177694\n",
      "117631084\n",
      "290605311\n",
      "29984021\n",
      "301896004\n",
      "30193373\n",
      "302965287\n",
      "304864057\n",
      "306108833\n",
      "340217291\n",
      "349154278\n",
      "349373192\n",
      "370134610\n",
      "370227480\n",
      "373840212\n",
      "373843852\n",
      "137501278\n",
      "276793626\n",
      "277022748\n",
      "277027632\n",
      "279957439\n",
      "326919774\n",
      "445417446\n",
      "18252911\n",
      "229751802\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.001862</td>\n",
       "      <td>0.169899</td>\n",
       "      <td>0.995803</td>\n",
       "      <td>0.001255</td>\n",
       "      <td>0.001149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000638</td>\n",
       "      <td>0.094291</td>\n",
       "      <td>0.997986</td>\n",
       "      <td>0.000905</td>\n",
       "      <td>0.001699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000130</td>\n",
       "      <td>0.099938</td>\n",
       "      <td>0.999345</td>\n",
       "      <td>0.000533</td>\n",
       "      <td>0.001904</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000681</td>\n",
       "      <td>0.098082</td>\n",
       "      <td>0.997602</td>\n",
       "      <td>0.001844</td>\n",
       "      <td>0.002561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000340</td>\n",
       "      <td>0.101546</td>\n",
       "      <td>0.999083</td>\n",
       "      <td>0.000228</td>\n",
       "      <td>0.000819</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000137</td>\n",
       "      <td>0.088219</td>\n",
       "      <td>0.999473</td>\n",
       "      <td>0.000230</td>\n",
       "      <td>0.001337</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.001828</td>\n",
       "      <td>0.154869</td>\n",
       "      <td>0.996766</td>\n",
       "      <td>0.000317</td>\n",
       "      <td>0.001720</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000279</td>\n",
       "      <td>0.097821</td>\n",
       "      <td>0.999276</td>\n",
       "      <td>0.000281</td>\n",
       "      <td>0.001417</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000802</td>\n",
       "      <td>0.113184</td>\n",
       "      <td>0.997519</td>\n",
       "      <td>0.000557</td>\n",
       "      <td>0.001394</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249951802</th>\n",
       "      <td>0.000477</td>\n",
       "      <td>0.075586</td>\n",
       "      <td>0.998610</td>\n",
       "      <td>0.000788</td>\n",
       "      <td>0.001280</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             disp_E    disp_N    disp_J    disp_S    disp_B\n",
       "tic_id                                                     \n",
       "249951802  0.001862  0.169899  0.995803  0.001255  0.001149\n",
       "249951802  0.000638  0.094291  0.997986  0.000905  0.001699\n",
       "249951802  0.000130  0.099938  0.999345  0.000533  0.001904\n",
       "249951802  0.000681  0.098082  0.997602  0.001844  0.002561\n",
       "249951802  0.000340  0.101546  0.999083  0.000228  0.000819\n",
       "249951802  0.000137  0.088219  0.999473  0.000230  0.001337\n",
       "249951802  0.001828  0.154869  0.996766  0.000317  0.001720\n",
       "249951802  0.000279  0.097821  0.999276  0.000281  0.001417\n",
       "249951802  0.000802  0.113184  0.997519  0.000557  0.001394\n",
       "249951802  0.000477  0.075586  0.998610  0.000788  0.001280"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 249951802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E_p</th>\n",
       "      <th>disp_N_p</th>\n",
       "      <th>disp_J_p</th>\n",
       "      <th>disp_S_p</th>\n",
       "      <th>disp_B_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E_p, disp_N_p, disp_J_p, disp_S_p, disp_B_p, maxcount, disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 404220255]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_E']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = float(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.991186434154996, max R: 1.0, max P: 1.0\n",
      "100% recall at: 68%, threshold: 0.06200000000005468\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    if p > 0:\n",
    "        ps.append(p)\n",
    "        rs.append(r)\n",
    "    else:\n",
    "        ps.append(1.0)\n",
    "        rs.append(0.0)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
